#include<iostream>
using namespace std;

// class HeapOnly
// {
// public:
// 	static HeapOnly* CreateObj()
// 	{
// 		return new HeapOnly;
// 	}

// 	HeapOnly(const HeapOnly&) = delete;
// 	HeapOnly& operator=(const HeapOnly&) = delete;
// private:
// //  构造函数私有化
// 	HeapOnly()
// 	{}
// };

// int main()
// {
// 	//static HeapOnly hp0;
// 	//HeapOnly hp1;
// 	//HeapOnly* hp2 = new HeapOnly;

// 	HeapOnly* hp3 = HeapOnly::CreateObj();
// 	//HeapOnly hp4(*hp3);
// 	delete hp3;

// 	return 0;
// }




// class HeapOnly
// {
// public:
// 	void Destroy()
// 	{
// 		delete this;
// 	}
// private:
// 	// 析构函数私有化
// 	~HeapOnly()
// 	{}
// };

// int main()
// {
// 	//static HeapOnly hp0;
// 	//HeapOnly hp1;
// 	HeapOnly* hp2 = new HeapOnly;
// 	//delete hp2;
// 	hp2->Destroy();

// 	return 0;
// }




//////////////////////////////////////////////////////
// class StackOnly
// {
// public:
// 	static StackOnly CreateObj()
// 	{
// 		return StackOnly();
// 	}

// 	//StackOnly(const StackOnly& s) = delete;
// 	void* operator new(size_t size) = delete;
// 	void operator delete(void* p) = delete;
// private:
// 	StackOnly()
// 		:_a(0)
// 	{}
// private:
// 	int _a;
// };

// int main()
// {
// 	//static StackOnly s1;
// 	//StackOnly s2;
// 	//StackOnly* s3 = new StackOnly;

// 	StackOnly s4 = StackOnly::CreateObj();

// 	//StackOnly* s5 = new StackOnly(s4);
// 	static StackOnly s6(s4);

// 	return 0;
// }






// class StackOnly
// {
// public:
// 	static StackOnly CreateObj()
// 	{
// 		return StackOnly();
// 	}

//     void* operator new(size_t size) = delete;
// 	void operator delete(void* p) = delete;

// 	StackOnly(StackOnly&& s)
// 	{}

// 	StackOnly(const StackOnly& s) = delete;
// private:
// 	StackOnly()
// 		:_a(0)
// 	{}
// private:
// 	int _a;
// };

// int main()
// {
// 	//static StackOnly s1;
// 	//StackOnly s2;
// 	//StackOnly* s3 = new StackOnly;

// 	StackOnly s4 = StackOnly::CreateObj();

// 	//StackOnly* s5 = new StackOnly(s4);
// 	//static StackOnly s6(s4);

// 	// 封不死
// 	static StackOnly s6(move(s4));
// 	// StackOnly* s5 = new StackOnly(move(s6));

// 	return 0;
// }







// 单例：全局只有唯一实例对象

// 饿汉模式
// 1、多个饿汉模式的单例，某个对象初始化内容较多(读文件)，会导致程序启动慢
// 2、A和B两个饿汉，对象初始化存在依赖关系，要求A先初始化，B再初始化，饿汉无法保证
// class InfoMgr
// {
// public:
// 	static InfoMgr& GetInstance()
// 	{
// 		return _ins;
// 	}

// 	void Print()
// 	{
// 		cout << _ip << endl;
// 		cout << _port << endl;
// 		cout << _buffSize << endl;
// 	}
// private:
// 	InfoMgr(const InfoMgr&) = delete;
// 	InfoMgr& operator=(const InfoMgr&) = delete;

// 	InfoMgr()
// 	{
// 		cout << "InfoMgr()" << endl;
// 	}
// private:
// 	string _ip = "127.0.0.1";
// 	int _port = 80;
// 	size_t _buffSize = 1024 * 1024;
// 	//...

// 	static InfoMgr _ins;
// };

// InfoMgr InfoMgr::_ins;


// int main()
// {
// 	InfoMgr::GetInstance().Print();
// 	//InfoMgr copy(InfoMgr::GetInstance());

// 	return 0;
// }



// 懒汉模式
// class InfoMgr
// {
// public:
// 	static InfoMgr& GetInstance()
// 	{
// 		// 第一次调用时创建单例对象
// 		// 线程安全的风险
// 		if (_pins == nullptr)
// 		{
// 			_pins = new InfoMgr;
// 		}

// 		return *_pins;
// 	}

// 	void Print()
// 	{
// 		cout << _ip << endl;
// 		cout << _port << endl;
// 		cout << _buffSize << endl;
// 	}

// 	static void DelInstance()
// 	{
// 		delete _pins;
// 		_pins = nullptr;
// 	}

// private:
// 	InfoMgr(const InfoMgr&) = delete;
// 	InfoMgr& operator=(const InfoMgr&) = delete;

// 	InfoMgr()
// 	{
// 		cout << "InfoMgr()" << endl;
// 	}
// private:
// 	string _ip = "127.0.0.1";
// 	int _port = 80;
// 	size_t _buffSize = 1024 * 1024;
// 	//...

// 	static InfoMgr* _pins;
// };

// InfoMgr* InfoMgr::_pins = nullptr;

// int main()
// {
// 	InfoMgr::GetInstance().Print();
// 	InfoMgr::GetInstance().Print();

// 	return 0;
// }





// class InfoMgr
// {
// public:
// 	static InfoMgr& GetInstance()
// 	{
// 		// 第一次调用时创建单例对象
// 		// C++11之后
// 		static InfoMgr ins;
// 		return ins;
// 	}

// 	void Print()
// 	{
// 		cout << _ip << endl;
// 		cout << _port << endl;
// 		cout << _buffSize << endl;
// 	}
// private:
// 	InfoMgr(const InfoMgr&) = delete;
// 	InfoMgr& operator=(const InfoMgr&) = delete;

// 	InfoMgr()
// 	{
// 		cout << "InfoMgr()" << endl;
// 	}
// private:
// 	string _ip = "127.0.0.1";
// 	int _port = 80;
// 	size_t _buffSize = 1024 * 1024;
// 	//...
// };



// int main()
// {
// 	InfoMgr::GetInstance().Print();
// 	InfoMgr::GetInstance().Print();

// 	cout << &InfoMgr::GetInstance() << endl;
// 	cout << &InfoMgr::GetInstance() << endl;

// 	return 0;
// }





//////////////////////////////////////////////////////////
//
// a、内置类型之间
// 1、隐式类型转换    整形之间/整形和浮点数之间
// 2、显示类型的转换  指针和整形、指针之间

// b、内置类型和自定义类型之间
// c、自定义类型和自定义类型之间

// int main()
// {
// 	int i = 1;
// 	// 隐式类型转换
// 	double d = i;
// 	printf("%d, %.2f\n", i, d);

// 	int* p = &i;
// 	// 显示的强制类型转换
// 	int address = (int)p;
// 	printf("%p, %p\n", p, address);

// 	return 0;
// }








// b、内置类型和自定义类型之间
// 1、自定义类型 = 内置类型  ->构造函数支持
// 2、内置类型 = 自定义类型
// class A
// {
// public:
// 	//explicit A(int a)
// 	A(int a)
// 		:_a1(a)
// 		,_a2(a)
// 	{}

// 	A(int a1, int a2)
// 		:_a1(a1)
// 		, _a2(a2)
// 	{}

// 	// ()被仿函数占用了，不能用
// 	// operator 类型实现，无返回类型
// 	//explicit operator int()
// 	operator int()
// 	{
// 		return _a1 + _a2;
// 	}
// private:
// 	int _a1 = 1;
// 	int _a2 = 1;
// };
// int main()
// {
// 	string s1 = "1111111";
// 	A aa1 = 1;
// 	//A aa1 = (A)1;
// 	A aa2 = { 2,2 };
// 	const A& aa3 = { 2,2 };

// 	int z = aa1.operator int();
// 	int x = (int)aa1;
// 	int x = aa1;
// 	int y = aa2;
// 	cout << x << endl;
// 	cout << y << endl;

// 	// std::shared_ptr<int> foo;
// 	// std::shared_ptr<int> bar(new int(34));

// 	// if (foo.operator bool())
// 	if (foo)
// 		std::cout << "foo points to " << *foo << '\n';
// 	else 
// 		std::cout << "foo is null\n";

// 	if (bar)
// 		std::cout << "bar points to " << *bar << '\n';
// 	else
// 		std::cout << "bar is null\n";

// 	return 0;
// }





// c、自定义类型和自定义类型之间 -- 对应的构造函数支持
// class A
// {
// public:
// 	A(int a)
// 		:_a1(a)
// 		, _a2(a)
// 	{}

// 	A(int a1, int a2)
// 		:_a1(a1)
// 		, _a2(a2)
// 	{}

// 	int get() const
// 	{
// 		return _a1 + _a2;
// 	}
// private:
// 	int _a1 = 1;
// 	int _a2 = 1;
// };

// class B
// {
// public:
// 	B(int b)
// 		:_b1(b)
// 	{}

// 	B(const A& aa)
// 		:_b1(aa.get())
// 	{}

// private:
// 	int _b1 = 1;
// };


// #include"List.h"
// #include<list>

// int main()
// {
// 	A aa1(1);
// 	B bb1(2);

// 	bb1 = aa1;
// 	B& ref1= bb1;
// 	const B& ref2 = aa1;

// 	ltw::list<int> lt = { 1,2,3,4 };
// 	// 权限的缩小？权限缩小和放大，仅限于const的指针和引用
// 	// 不是权限缩小，这里类型转换
// 	ltw::list<int>::const_iterator cit = lt.begin();
// 	while (cit != lt.end())
// 	{
// 		cout << *cit << " ";
// 		++cit;
// 	}
// 	cout << endl;

// 	return 0;
// }



// int main()
// {
// 	// 对应隐式类型转换 -- 数据的意义没有改变
// 	double d = 12.34;
// 	int a = static_cast<int>(d);
// 	cout << a << endl;
	
// 	// 对应强制类型转换 -- 数据的意义已经发生改变
// 	int* p1 = reinterpret_cast<int*>(a);

// 	// 对应强制类型转换中有风险的去掉const属性
// 	// volatile const int b = 2;
// 	// int* p2 = const_cast<int*>(&b);
// 	// *p2 = 3;

// 	// cout << b << endl;
// 	// cout << *p2 << endl;
//     const int b = 2;
//     int* p2 = (int*)&b;
//     *p2 = 3;
//     cout << (*p2) << endl;
//     cout << b << endl;

// 	return 0;
// }












class A
{
public:
	virtual void f() {}

	int _a = 1;
};

class B : public A
{
public:
	int _b = 2;
};

void fun(A* pa)
{
	// dynamic_cast会先检查是否能转换成功，能成功则转换，不能则返回
	// 指向父类转换时有风险的，后续访问存在越界访问的风险
	// 指向子类转换时安全
	B* pb1 = (B*)pa;
	cout << "pb1:" << pb1 <<endl;
	cout << pb1->_a << endl;
	cout << pb1->_b << endl;
	pb1->_a++;
	pb1->_b++;
	cout << pb1->_a << endl;
	cout << pb1->_b << endl;
}




void fun(A* pa)
{
	// dynamic_cast会先检查是否能转换成功(指向子类对象)，能成功则转换，
	// (指向父类对象)不能则返回NULL
	B* pb1 = dynamic_cast<B*>(pa);
	if (pb1)
	{
		cout << "pb1:" << pb1 << endl;
		cout << pb1->_a << endl;
		cout << pb1->_b << endl;
		pb1->_a++;
		pb1->_b++;
		cout << pb1->_a << endl;
		cout << pb1->_b << endl;
	}
	else
	{
		cout << "转换失败" << endl;
	}
}

int main()
{
	A a;
	B b;
	// fun(&a);
	fun(&b);

	return 0;
}